<simpleNode>

	Maybe each node should have 2 sets of nodes, size X and Y,
	and include 1 set of floating points, size X^Y. For normal bayes node, X is [false,true] and size 2.
	
	What does it mean when [false,true] is replaced in some nodes with [dog,cat,tree]?
	
	Does it mean to connect nodes between the 2 sets? That would be a good algorithm if some of the
	nodes in each set were networks instead of nodes, and only parts of those networks were connected.
	
	Neural node is [many nodes...]^[simpleNumberType]. For example, 100^1 is a node with 100 childs and 100 weights.
	
	How can multiple types of number set be used?
	For example, a bayesian node algorithm may use 1 number + 2*7 numbers + 2^7 numbers.
	This example is 2 or 3 sets of X^Y:
		2*7 is the set resulting from mutliplying 2 sets: 2^1 * 7^1.
		2^7 is already a set.
	How should these 2 or 3 sets be used by the same algorithm, which executes 2^7 times per node execution?
	Example, iterate someFunc(fromSetOf2, fromSetOf7, fromSetOf2Power7) 2^7 times, each time allowing read and/or write of each var.
	
	
	Would that work for a node that has a 2^11 set and a 11^3 set, where its the same set of 11^1 each time?
	
	For example, read the 11^3 numbers and write the 2^11 numbers.
	From normal bayesian softwares, we know how to create 2^11 numbers from many samples of 11 numbers each (sampleCount * 11^1),
	and that usually ignores the order of the samples (sampleCount is a set, not a list) which is ok here too.
	In this example, its not a linear number of samples. sampleCount is not a number. Its branching in a network.
	The meaning of the 11^3 should not be defined here. It should be defined at runtime, possibly evolved.
	What I'm trying to decide here is which of the 11^3 numbers to pair with which of the 2^11 numbers in function calls.
	
	The function may be like someFunc(numberFrom2Power11Set, numberFrom11Power3Set) and iterate 11^3 (or 11^3 * 2^11?) times.
	Or it may be like someFunc(numberFrom2Power11Set, numberFrom11Power3Set_0, numberFrom11Power3Set_1, numberFrom11Power3Set_2).
	There are many possible combinations,
	and it may be necessary to create a few types of iteration to handle all the EXPONENT types, that can be chosen at runtime.
	
	In this example, in 2^11 and 11^3, the sets of 11 are the same set, and the sets of 2 and 3 are different sets.
	That does not mean the sets of 2 and 3 could not be the same size, just that they would still be different sets.
	The size of sets can change at runtime, but the way of pairing numbers from all sets together does not change as often.
	If the sets of 11 were not the same set, this would be a PLUS problem instead of EXPONENT problem, which is much different.
	
	If it was 2^11 and 11^2 and both were the same sets of 2 and 11, it appears to be a little easier.
	Call someFunc(numberFrom2Power11Set, numberFrom11Power2Set) 2^11 times.
	The bigger of 2^11 and 11^2 defines the number of iterations so all numbers from both sets are used.
	
	If we had 3 sets of 2^11: [x,y]^11, [y,z]^11, and [z,x]^11,
	then maybe they could be combined to use with 11^[x,y,z], but that would not use all possible info in 11^3.
	
	A node type which I think will work well is [f,t]^[bayesChilds] and [f,t]*[bayesChilds], iteration size [f,t]^[bayesChilds].
	For each bayesian weight, it adds it to the t or f sum for that child. For each child, the 2 numbers t and f should sum to 1.
	This is the simpler case described above with the example of 2^11 and 11^2.
	someFunc(inX, inY, inXPowerY) iteration size X^Y.
	
	Sets of size X^1, Y^1, and X^Y are too simple.
	What would it do with X^1, Y^3, and X^Y?
	Would the function take 1 X and 3 Y and 1 X^Y parameter? That prevents changing the 3 at runtime.
	How to know which indexs of X and Y the number from X^Y is? Some functions dont need that info,
	but if it uses 2 sets where neither is a subset of the other, like Y^3 and X^Y, we probably need to know the indexs,
	and that can not be allowed to affect the output of the node execution because the childs must be used as order not mattering.
	
	Does it make sense for Y^3 to be combined with X^Y, where 3 < Y?
	For each set of 3 bayesNode (allowing duplicates) from Y^3, there is 1 floating point number.
	That is like a neural net but more advanced. A neural net has a number for each pair of nodes,
	but Y^3 has number for each triple.
	If order mattered, this could be viewed as numbers weighting paths of length 3 through a neural network.
	But correctly viewed as unordered, it weights the combination of 2 neural net edges which share a node.
	X^Y (where 3 < Y) can store more info than Y^3, but should be able to
	transfer a lot more of its info to Y^3 than it could to Y^2 or Y^1.
	
	Similarly, X^Y can transfer much of its into into Y^4, but Y^4 has a better analogy to neural nets.
	For each edge in Y^2, view it as a node. Do that again for the other Y^2 in Y^4, and view all that
	as (Y^2)^2 edges. In other words, as edges between each 2 edges.
	This is simple because the network has all possible edges.
	
	To combine [b,c,d]^[v,w,x,y,z] with [c,d,e,f]^[s,t,u,w,x,z], first remove things from each that are not in both.
	Combine [c,d]^[w,x,z] with the other [c,d]^[w,x,z].
	Using the variables they dont share should be done but requires using other nodes that have those vars and some of these vars.
	What if X and Y in X^Y share a node. For example [a,b]^[b,c,d].
	Interpret "in both" separately for X and Y in each set of X^Y.
	That doesnt work in the common case of [a,b]^[x,y,z] with [x,y,z]^[a,b]
	
	[false,true]^[node1, ... node5] --> [node1, ... node5]^[false] and [node1, ... node5]^[true]
	Or allowing multiply of sets:
	[false,true]^[node1, ... node5] --> [node1, ... node5] * [false,true]
	
	What if the same vars are there but one moves between the sets differently than the others?
	[false,true]^[otherVar, node1, ... node5] --> [node1, ... node5] * [false,true,otherVar]
	It may simplify this to copy otherVar before moving it:{
		[false,true]^[otherVar, node1, ... node5] --> [otherVar, node1, ... node5] * [false,true,otherVar]
		
		for each pair [x,y] in [false,true]^[otherVar, node1, ... node5], where x is false or true, and y is in [otherVar, node1, ... node5]:{
			y is always in [otherVar, node1, ... node5] so that works both places.
			x is more complex because its in both sets, and would still be complex if it was only in 1 set because its not the set you expect.
			if(x == y){ //x is otherVar
				Trying to create [otherVar, node1, ... node5] * [false,true,otherVar]...
				
			}else{ //x is false or true
				Trying to create [otherVar, node1, ... node5] * [false,true,otherVar]...
				if(x == otherVar){ //and y does not
					New info must be created.
					y is selected from its original set, nothing unusual there.
					x is not selected from its original set. It is the otherVar which is being added.
					Where would this new info come from?
					It probably does not make sense to use only this node to create that info
					because it had no concept of otherVar being in the [false,true] set, where we are trying to add it.
					
				}else if(y == otherVar){ //and x does not
					Because y is selected from a set which already contained otherVar, this works normally. The 2 indexs are y and x.
				}else{ //neither is otherVar
					This works the normal way. The 2 indexs are y and x.
				}
			}
		}

	}
	Then remove the original otherVar:{
		[otherVar, node1, ... node5] * [false,true,otherVar] --> [node1, ... node5] * [false,true,otherVar]
		
	}
	
	An evolved node algorithm is some sequence of iterations (and thing to do during each iteration) over different sets of child nodes,
	where each node has multiple sets of childs and multiple sets of floating point numbers mapped to 2 or more sets of childs connected by some operator like POWER or MULTIPLY, usually resulting in modified floating point numbers in 1 or more of the sets.
	That should be extended to allow modifying the numbers of the child nodes but not recursively.
	
	
	Need to define the object types. For example, does a node have exactly 2 sets of nodes or multiple sets?
	Can a node share these sets of nodes with other nodes?
	How many sets of floating point numbers (which map to sets of nodes) does a node have? Always 1? More?
	Are a node and network the same type of thing?
	Does a network have algorithms for all nodes in it, or can each node have different algorithms, or some combination of those?
	What object chooses to create new nodes or add or remove child nodes from existing nodes?
	
	It would require some of the nodes have different quantity of sets and different algorithms than other nodes,
	but it would work for a node to be defined as 1 set of child nodes and 1 set of floating points, and the sizes of those are usually not equal.
	Instead of a node having multiple sets of sets of node, each of those multiple sets would be a node with floating point set size 0.
	
	An example of these simpler nodes may help...
	node#bayesMetaNode(
		list#privateNodes(
			node#nodeContainingBayesChilds(
				list#childsB(bayesChildNode0 bayesChildNode1 bayesChildNode2...)
				doubleArray#noNumbers()
				...should an anonymous function be third parameter?...
			)
			node#nodeContainingSetOfFalseAndTrue(
				list#childsTF(node#falseNode node#trueNode)
				doubleArray#noNumbers()
				...should an anonymous function be third parameter?...
			)
			node#nodeContainingTemporaryNumbers(
				list#noChilds()
				doubleArray#temporaryNumbers(...quantity is size of childsB multiplied by size of childsTF...)
				...should an anonymous function be third parameter?...
			)
		)
		doubleArray#bayesWeights(...quantity is size of childsTF power size of childsB...)
		...should an anonymous function be third parameter?...
	)
	
	
	This example is probably too complex. Lets see...
	complexNode(
		list#childsB(complexNode0 complexNode1 complexNode2...)
		list#childsTF(complexNode#falseNode complexNode#trueNode)
		doubleArray#temporaryNumbers(...quantity is size of childsB multiplied by size of childsTF...)
		doubleArray#bayesWeights(...quantity is size of childsTF power size of childsB...)
		doubleArray#numbersForThisNodeShallowly(3 numbers for: estimatedChance, howMuchKnowChance, howMuchWantToKnowChance)
		doubleArray#numberUsedToSortThisNodeInANetwork(1 number)
	)
	
	
	Maybe this is more organized, but it has more synchronization problems.
	It does not remove any of the dependencies or tell you how to use the 2 child lists differently.
	complexNode(
		list(
			list#childsB(complexNode0 complexNode1 complexNode2...)
			list#childsTF(complexNode#falseNode complexNode#trueNode)
		)
		list(
			doubleArray#temporaryNumbers(...quantity is size of childsB multiplied by size of childsTF...)
			doubleArray#bayesWeights(...quantity is size of childsTF power size of childsB...)
			doubleArray#numbersForThisNodeShallowly(3 numbers for: estimatedChance, howMuchKnowChance, howMuchWantToKnowChance)
			doubleArray#numberUsedToSortThisNodeInANetwork(1 number)
		)
		list(
			...anonymous function to execute this bayes node...
			...anonymous function to create temporary numbers...
			...anonymous function to use temporary numbers...
			...anonymous function to add a child to this bayes node?...
		)
	)
	
	It would help me to choose a representation of a node to consider what other X and Y in X^Y it will use.
	For example, X and Y could both be sets of bayes nodes, which is useful for choosing which new nodes to connect or create.
	
	
	What was i writing about duplicate nodes in the temporary sets above? A neural net with N^3 numbers can duplicate the same node 3 times?
	I dont see how a bayesian node would represent such duplication. I think I remember... true and false are duplicated, but nodes are not.
	
	Can a function be represented as a node where its parameters are its childs? Is it efficient to set the parameters that way?
	Is it good design for each node object to be a function?
	
	

</simpleNode>